print("字符串是一串字符组成的不可变序列：字符可以是字母，数字，符号，空格等")
print("以下是几个字符串：")

print("以下一到八为原始字符串")
string_1="abc"
string_2="a,c,b"
string_3="132"
string_4="1,2,3"
string_5="(1,2,3)"
string_6="[1,2,3]"
string_7="{a,b,c}"
string_8="{\"a\":1,\"b\":2}"           #\转义
string_16='this isn\'t a number'
string_17="red,\n blue,\n black"
string_18=string_4[1],string_8[2]


print("通过索引查找某个字符串中想要查找的字符：")

print("打印第1个字符串： %s" % string_1)
print("打印第2个字符串： %s" % string_2)
print("打印第3个字符串： %s" % string_3)
print("打印第4个字符串： %s" % string_4)
print("打印第5个字符串： %s" % string_5)
print("打印第6个字符串： %s" % string_6)
print("打印第7个字符串： %s" % string_7)
print("打印第8个字符串： %s" % string_8)
print("打印第16个字符串： %s" % string_16)
print(f"打印第17个字符串： %s" % string_17)        #f的含义是什么？意义是什么？
print("打印第18个字符串： %s %s " % string_18)
print("输出string_18的数据类型： %s " % type(string_18))


print('''
       给第一个字符串进行倒序排序：%s 
       给第二个字符串进行顺序排序：%s
       给第三个字符串进行顺序排序：%s
      ''' % (
               string_1[::-1],
               sorted(string_2),                   #??????
               sorted(string_3)
            )
      )
print(type(string_1[::-1]))
print(type(sorted(string_2)))
print(type(sorted(string_3)))

print('''
       输出string_1[::-1]的数据类型：%s 
       输出sorted(string_2)的数据类型：%s
       输出sorted(string_3)的数据类型：%s
      ''' % (
               type(string_1[::-1]),
               type(sorted(string_2)),                   #??????为什么经过排序后数据类型改变了???
               type(sorted(string_3))
            )
      )

print("查找第3个字符串的第2个字符：%s" % string_3[1])
print("查找第5个字符串的第1个字符和第3个字符：%s %s" % (string_5[0],string_5[2]))
print("查找第8个字符串的第5个字符和第9个字符：%s %s" % (string_8[4],string_8[8]))
print("输出第6个字符串的长度： %s " % len(string_6))

print("以下为通过原始字符串得到的是新的字符串")

string_14="abc""a,b,c"                             #两个字符串直接相邻
print("两个字符串直接相邻得到新的第十四个字符串： %s " % string_14) 
print("输出string_14的数据类型： %s " % type(string_14))
print("查找第14个字符串的第五个字符： %s " % string_14)
print("abc""a,b,c")

string_9=string_1+string_4+string_8                 #加号"+"拼接
print("加号拼接得到新的第九个字符串： %s " % string_9) 
print("输出string_9的数据类型： %s " % type(string_9))
print("查找第9个字符串的第8个字符： %s " % string_9[7])
print("查找第9个字符串的第9个字符和第4个字符串的第4个字符：%s %s" % (string_9[8],string_4[3]))
print("查找第9个字符串的第2个字符到第4个字符的子字符串： %s " % string_9[1:4])       #?????
print("输出第9个字符串的长度： %s " % len(string_9))

string_10="".join([string_5,string_7])             #变量=" ".join(),大量拼接适用，双引号分开的话会占用字符
print("用join法得到新的第十个字符串：%s " % string_10)
print("输出string_10的数据类型： %s " % type(string_10))
print("查找第10个字符串的第八个字符：%s " % string_10[7])
print("查找第10个字符串的第7个字符到第8个字符的子字符串： %s " % string_10[6:8])
print("输出第10个字符串的长度： %s " % len(string_10))

string_11=f"{string_3}{string_4}"                    #带格式用f-string拼接
print("f-string法得到新的第十一个字符串： %s " % (string_11))
print("输出string_11的数据类型: %s " % type(string_11))
print("查找第11个字符串的第3个字符和第5个字符：%s %s" % (string_11[2],string_11[4]))



print("以下为通过原始字符串得到的是新的元组：")

string_12=(string_1,string_2,string_5)
print("设置一个新的变量string_12，值为用逗号隔开的几个变量，输出为：%s  %s %s " % string_12)  
print("输出string_12的数据类型: %s " % type(string_12))    #???输出的元组为什么没有用括号括起来
print("查找第12个数据类型的第2个参数到3个参数： %s %s  " % string_12[1:3])        #??????格式说明符的个数和字符串的区别
print("输出string_12的长度： %s " % len(string_12))

string_13="abc","a,b,c"
print("输出第13个变量的长度：%s " % len(string_13))
print("设置一个新的变量string_13，值为用逗号隔开的几个变量，输出为：%s  %s " % string_13)  #??????
print("输出string_13的数据类型: %s " % type(string_13))     #???输出的元组为什么没有用括号括起来
print("查找第13个数据类型的第1个参数： %s " % string_13[0])


print("print函数接受多个参数，按顺序打印出来")
print("用逗号隔开第一个字符串和第二个字符串,输出的结果为两个不同的值字符串: %s %s" % (string_1,string_2))
print(string_1,string_2)

#string_15=string_1 string_2         #无效语法
#print(string_15)

print("字符串的替换可使用：replace：")
string_1_new=string_1.replace("b","nnn")
print("将第一个字符串的b换成nnn后生成一个新的字符串为 : %s " % string_1_new)

string_2_new=string_1_new.replace("n","m",2)
print("字符串里面的n替换成m，替换两次，得到新的字符串：%s" % string_2_new)







print('元祖是一个可变的，有序的元素集合，可以包含任意类型的元素（数字，列表，字符串，字典，其他元组等），逗号是创建元组的语法，括号是可选的')


tuple_1=("string","filled","by a","tuple")   #创建一个元组
tuple_2=1,2,3                                               #没有加括号，用逗号将元素隔开，创建的也是元组
tuple_3="c","d",4,5,[6,7],{"a":1,"b":2},("e","f")     #复合型元组

print("A %s %s %s %s" % ("string","filled","by a","tuple"))
#print("A %s %s %s %s" % ("string""filled""by a""tuple"))    #去掉逗号后是不是元祖只有一个元素？？？
print("A %s " % ("string"" ""filled"" ""by a"" ""tuple"))    #去掉逗号后%后面元组里面是一个字符串参数,字符串与字符串中间的空白引号是为了是为了蒋字符串空格隔开
print("第一个元组的输出结果为：%s %s %s %s" % tuple_1)
print("不用格式说明符输出的结果为：",tuple_1)                   #?????对比两种输出
print("第二个元组的输出结果为：%s %s %s " % tuple_2)
print("第三个元组的输出结果为：%s %s %s %s %s %s %s" % tuple_3)

print("第一个，第二个，第三个元组分别的输出类型：%s %s %s" % 
        (
          type(tuple_1),
          type(tuple_2),
          type(tuple_3)
        )
     )

print("给第三个元组进行倒序：%s %s %s %s %s %s %s " % tuple_3[::-1])
print("输出元组倒序后的数据类型：%s" % type(tuple_3[::-1]))

print("通过索引查找某个元组中想要查找的元素：")

print("the first element of the tuple is %s" % (tuple_1[0]))       #给元祖命名，嵌套
print("the second element of the tuple is %s" % (tuple_1[1]))
print("the all element of th tuple is %s %s %s %s" % tuple_1)
print("the all element of th tuple is %s %s %s %s" %( tuple_1))

print(type(tuple_3[5]))
print(len(tuple_3[1:6]))
print('''
    查找第三个元组中的字典元素：%s 
    查找第三个元组中的字典的第一个元素的值：%s
    查找第三个元组中的列表的第一个元素：%s
    查找第三个元组中的元组的第二个元素：%s
    查找第三个元组中的第二个元素到第六个元素：%s
    查找第一个元组中的第二个元素和第二个元组的第3个元素：%s %s
    查找第三个元组中的最后一个元素：%s
    查找第三个元组的倒数第2个到倒数第3个的元素：%s
    ''' % (tuple_3[5],
           tuple_3[5]["a"],
           tuple_3[4][0],
           tuple_3[6][1],
           tuple_3[1:6],                 #??????
           tuple_1[1],
           tuple_2[2],
           tuple_3[len(tuple_3)-1],
           tuple_3[(len(tuple_3)-3):(len(tuple_3)-1)]        #?????
          )
     )

print("确认起始索引大于结束索引,且步长为正数返回的值是： " % tuple_3[(len(tuple_3)-1):(len(tuple_3)-3)])   #起始索引大于结束索引，且默认步长为1，正数，切片无法从高索引向低索引正数移动，切片会返回空序列，起始索引小于结束索引，且为负数，切片也会返回空序列
print(tuple_3[(len(tuple_3)-1):len(tuple_3)-3])
print("确认起始索引大于结束索引,且步长为负数返回的值是：%s %s " % tuple_3[(len(tuple_3)-1):(len(tuple_3)-3):-1])   #??????
print("确认起始索引小于结束索引,且步长为负数返回的值是： " % tuple_3[(len(tuple_3)-3):(len(tuple_3)-1):-1]) 
print(tuple_3[(len(tuple_3)-3):(len(tuple_3)-1):-1])
print("确认起始索引小于结束索引,且步长为正数返回的值是：%s %s " % tuple_3[(len(tuple_3)-3):(len(tuple_3)-1):1])


print('''
    第一个元组的长度：%s
    第二个元组的长度：%s
    第三个元组的长度：%s
    第三个元组最后一个元素的长度：%s
    ''' % (len(tuple_1),
           len(tuple_2),
           len(tuple_3),
           len(tuple_3[len(tuple_3)-1])
          )
     )
            


print("元祖里面的元素可以是对另一个元祖的引用")
a=("first","second","third")           #去掉逗号a元祖里面的三个字符串会合并为一个元素
b=(a,"b‘s second element")
print(b)
print("%s  %s  " % (b))                 #??????
print("%s %s %s b's second element"%("first","second","third"))


print('%s %%d:%d ' % ("percent",5))

print("通过一个元祖访问另一个元祖")
print("%s" % (b[0][0]))
print("%s" % (b[1]))
print("%s" % (b[-1]))
print(b[0][1])

layer2=b[0]
print(layer2[2])

single_element_tiple=("the sole element",)              #由于只包含一个元素的元祖，必须在该元素后加一个逗号，以免与字符串混淆
print(single_element_tiple)
single_element_tiple_1=("the sole element")
print(single_element_tiple_1)
single_element_tiple_2="the sole element"
print(single_element_tiple_2)



print("列表")
breakfast=["coffee","tea","toast","egg"]
count=0
print("today's breakfast is %s" % breakfast[count])
count=2
print("today's breakfast is %s" % breakfast[count])

print("today's breakfast is %s" % breakfast)
print(len(breakfast))
print("today's breakfast is %s %s %s %s " % (breakfast[0],breakfast[1],breakfast[2],breakfast[3]))

print("列表在任何时候都可以被修改")
breakfast[count]="sausages"
print("today's breakfast is %s" % breakfast[count])
print(breakfast)
breakfast[3]="hdks"
print(breakfast)

print("在列表末端添加一个元素使用append")
breakfast.append("waffles")
print(breakfast)

print("在列表末端添加多个元素使用extend")
breakfast.extend(["j","d","c"])           #在列表里面添加的是列表中的三个元素
print(breakfast)
breakfast.extend("j""d""c")            #在列表里面添加的是字符串
print(breakfast)
breakfast.extend(["j""d""c"])         #一个元素列表
print(breakfast)
breakfast.extend([3,4,5])
print(breakfast)
#breakfast.extend(3，4,5)
#print(breakfast)


print("创建字典")
'''menus_specials={}             #用花括号创建了一个空字典
menus_specials["breakfast"]="candian ham"
print(menus_specials)
menus_specials["lunch"]="tuna surprise"
menus_specials["dinner"]="cheeseburger duluxxe"
print(menus_specials)
'''
menus_specials={"breakfast":"sausage an eggs",
"lunch":"split pea soup and garlic bread",
"dinner":"2 hot dogs and onion rings"}

print(menus_specials)
print("%s" % menus_specials["breakfast"])


shenfenzheng={
	"first_name":"Zhang ",
	"last_name":"qi chuan",
	"birsday":"92_08_07",}
print(shenfenzheng)

print("这个人姓   %s ，  生日是  %s      " % (shenfenzheng["first_name"],shenfenzheng["birsday"]))

print("这个人姓  " ,shenfenzheng["first_name"], "生日是：",shenfenzheng["birsday"])

shenfenzheng["birsday"]="1990-01-01"
print("这个人的修改后的生日已经更改为："   ,  shenfenzheng["birsday"])

print(shenfenzheng)
print("求字典的长度：",  len(shenfenzheng))

students={}
students["张三"]=" 身份证：67286, 地址：进度款收到, 生日：900101"              #此方法不通   要查找数据的时候不可行
students["李四"]=" 身份证：08988, 地址：怀旧服电话, 生日：929897"
print(students)
print("查找李四的身份信息   %s："  %   students["李四"])


tist=[{"Name":"Zhangsan","ID":"123456","Birth":"90-01-01","Adres":"CD"},
{"Name":"Lisi","ID":"789654","Birth":"92-03-01","Adres":"SL"}]
a=tist[0]
print("查出所有学生的资料信息：",tist)
print(a)
print("调出第一个同学的的身份证信息：",tist[0]["ID"])
tist[0]["Birth"]="87-02-03"
print("第一个同学的身份信息有误，需修改为",tist[0]["Birth"])
b=a.keys()
print("获取字典中的键：",list(b))
c=a.values()
print(c)
print("获取字典中的值",list(c))         #？？？？怎样使获取的信息换行
print("查出第一个同学姓名的首字母:" ,a["Name"][0])
print("查出第一个同学姓名的首字母：%s"  %   a["Name"][0])

last_names=["douglass","jefferson","williams","frank","thomas"]
print("输入第一个名：%s"% last_names[0])
print("输入第一个名的第一个字符：%s" % last_names[0][0])
print("输入第二个名的第一个字符：%s" % last_names[1][0])
last_names.append("tom")
print("列表增加了一个字符串",last_names)

print("访问last_names中的最后一个元素：",last_names[len(last_names)-1])
print("访问last_names中的最后一个元素:%s" % last_names[-1])
print("访问last_names中的最后一个元素的首字符：",(last_names[len(last_names)-1])[0])


living_room=("rug","table","chair","tv","dustbin","shelf")
apartment=[]
#apartment.append(living_room)
#print("建立一个新的列表序列，使该列表包含该元祖的所有元素：",apartment)
apartment.extend(living_room)
print("建立一个新的列表序列，使该列表包含该元祖的所有元素：",apartment)


todays_temperatures=[23,32,33,31]
todays_temperatures.append(29)
print(todays_temperatures)
morning=todays_temperatures.pop(0)
print("tadays mornings temperatures was %0.02f " % morning)
late_morning=todays_temperatures.pop(0)
print("todays late_mornings temperatures was %0.02f "  %  late_morning)
moon=todays_temperatures.pop(1)
print("todays moon todays_temperatures was %0.02f" % moon)
print("afternoon temperatures was %0.02f"%todays_temperatures.pop())
print(todays_temperatures)

print("删除重复元素：将值赋给一个集合删除重复的元素")
alphabet=['a','b','b','d','e','f','f']
print(alphabet)
alph2=set(alphabet)
print("去掉重复的元素：",alph2)



print("比较左右两端数值是否相等",1==1)
print("比较左右两端数值是否相等",1==2)
print("比较左右两端数值是否相等",1==1.00)

yu="mackintosh apples"
yh="black berries"
yj="golden delicious apples"
print("判断yu与yh两个字符串是否相同：",yu==yh)
print("判断yh与yj两个字符串是否相同：",yh==yj)
yk=yu[-len('apples'):-1]
yl=yj[-len('apples'):-1]
print("判断yk和yl是否相等",yk==yl)
print("判断yu和yj最后6个字符是否相等",yu[-len("apples"):-1]==yj[-len("apples"):-1])


#gszzjg=[{"com":"A公司","add":"成都","股东":{"股东1":"张三",}]




'''

gszzjg=[
         {  
           "com":"A公司",
           "add":"成都",
           "股东":[
                   "张三",
                   "李四"
                   ],
           "员工":[
                   {
                    "姓名":"小李",
                    "年龄":20,
                    "性别":"女",
                    "薪资等级":"A",
                    "入职时间":"20-5-1"
                   },
                   {
                    "姓名":"小王",
                    "年龄":30,
                    "性别":"男",
                    "薪资等级":"A+",
                    "入职时间":"23-5-3",
                    }
                   ],
            "薪资等级":{
                       "A":{
                            "基本工资":2000,
                            "绩效":1000,
                            "餐补":600
                            },
                       "A+":{
                             "基本工资":3000,
                             "绩效":1500,
                             "餐补":800
                            }
                         },              
          },
          {
            "com":"B公司",
            "add":"绵阳",
            "股东":[
                   "王五",
                   "刘六"
                   ],
            "员工":[
                    {
                     "姓名":"小刘",
                     "年龄":23,
                     "性别":"女",
                     "薪资等级":"A",
                     "入职时间":"25-5-1"
                    },
                    {
                     "姓名":"小杨",
                     "年龄":31,
                     "性别":"男",
                     "薪资等级":"A+",
                     "入职时间":"21-5-3",
                     }
                   ],
             "薪资等级":{
                         "A":{
                             "基本工资":2500,
                             "绩效":1200,
                             "餐补":600
                             },
                        "A+":{
                              "基本工资":3400,
                              "绩效":1800,
                              "餐补":800
                             }
                        },                         
          }
          ]

'''

gszzjg={
        "A公司":{  
                   "add":"成都",
                   "股东":[
                           "张三",
                           "李四"
                          ],
                   "员工":{
                             "小李":{  "姓名":"小李",
                                       "年龄":20,
                                       "性别":"女",
                                       "薪资等级":"A",
                                       "入职时间":"20-5-1"
                                     },
                               "小王":{  "姓名":"小王",
                                         "年龄":30,
                                         "性别":"男",
                                         "薪资等级":"A+",
                                         "入职时间":"23-5-3",
                                        }
                           },
                 "薪资等级":{
                             "A":{
                                   "基本工资":2000,
                                   "绩效":1000,
                                   "餐补":600
                                 },
                            "A+":{
                                   "基本工资":3000,
                                   "绩效":1500,
                                   "餐补":800
                                 }
                             },              
                   },
           "B公司":{
                    "add":"绵阳",
                    "股东":[
                            "王五",
                            "刘六"
                           ],
                    "员工":{
                            "小刘":{   "姓名":"小刘",
                                       "年龄":23,
                                       "性别":"女",
                                       "薪资等级":"A",
                                       "入职时间":"25-5-1"
                                     },
                             "小杨":{  "姓名":"小杨",
                                       "年龄":31,
                                       "性别":"男",
                                       "薪资等级":"A+",
                                       "入职时间":"21-5-3",
                                     }
                             },
                 "薪资等级":{
                              "A":{
                                    "基本工资":2500,
                                    "绩效":1200,
                                    "餐补":600
                                  },
                             "A+":{
                                    "基本工资":3400,
                                    "绩效":1800,
                                    "餐补":800
                                  }
                            },                         
                   }
           }
          



#print(gszzjg)
#print(gszzjg["A公司"])
print(gszzjg["A公司"]["员工"]["小李"],gszzjg["A公司"]["薪资等级"]["A"]["餐补"])


student={ 
             "123456":{
                        "name":"zhang",
                        "ID":123456,
                        "math":89,
                        "english":99
                      },
	           "157788":{
                        "name":"liu",
                        "ID":157788,
                        "math":98,
                        "english":88,
                        "xingquaihao":('changge','tiaowu','dapingpang')
                      },
               "8977897":{
                        "name":"liu",
                        "ID":8977897,
                        "math":78,
                        "english":98,
                        "cailiao":80,
                      },        
          }
print("查询某某的兴趣爱好:%s"%   student["157788"]["xingquaihao"][0])


tuple_1=(10,"hj",True)
#tuple_2=(10,"hj",ture)
print(tuple_1)
#print(tuple_2)

users = (
    {"id": 101, "name": "Alice", "role": "admin"},
    {"id": 102, "name": "Bob", "role": "user"}
    )
users[0]["email"] = "alice@example.com"
print(users[0]["email"])
print(users)










        






print("%.2f"% (5/3))
print("%.0000002f"% (5/3))
print("%.42f"% (5/3))








'''
by_letter={}
by_letter[last_names[0][0]]=last_names[0]
by_letter[last_names[1][0]]=last_names[1]

print(by_letter)
print(last_names)
'''





'''
a=[1,2,3]
b=("a","b","c")

#c=(d,e,f)
a[1]=6
print(a)
#b[1]="t"
print(b)
print("%s %s %s" % (b))
'''


tuplr=('j','k')+('f','g','h')
print(tuplr)
dict_5={'d':2,'g':5}
dict_1={'f':6,'j':7}
dict_5["f"]=6
dict_5.update({"j":6,"k":9})
print(a)
dict_5["g"]=20
print(dict_5)
valiu=dict_5.pop("j")
print(valiu)
del dict_5["g"]
print(dict_5)
dict_5.clear()
print(dict_5)



print(5!=4)
for i in range(10,0,-1):

   print("t-minus:   ",end="")
   print(i)




